home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / command / install_lib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  6.1 KB  |  164 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. __revision__ = '$Id: install_lib.py,v 1.44 2004/11/10 22:23:15 loewis Exp $'
  5. import sys
  6. import os
  7. import string
  8. from types import IntType
  9. from distutils.core import Command
  10. from distutils.errors import DistutilsOptionError
  11. PYTHON_SOURCE_EXTENSION = os.extsep + 'py'
  12.  
  13. class install_lib(Command):
  14.     description = 'install all Python modules (extensions and pure Python)'
  15.     user_options = [
  16.         ('install-dir=', 'd', 'directory to install to'),
  17.         ('build-dir=', 'b', 'build directory (where to install from)'),
  18.         ('force', 'f', 'force installation (overwrite existing files)'),
  19.         ('compile', 'c', 'compile .py to .pyc [default]'),
  20.         ('no-compile', None, "don't compile .py files"),
  21.         ('optimize=', 'O', 'also compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]'),
  22.         ('skip-build', None, 'skip the build steps')]
  23.     boolean_options = [
  24.         'force',
  25.         'compile',
  26.         'skip-build']
  27.     negative_opt = {
  28.         'no-compile': 'compile' }
  29.     
  30.     def initialize_options(self):
  31.         self.install_dir = None
  32.         self.build_dir = None
  33.         self.force = 0
  34.         self.compile = None
  35.         self.optimize = None
  36.         self.skip_build = None
  37.  
  38.     
  39.     def finalize_options(self):
  40.         self.set_undefined_options('install', ('build_lib', 'build_dir'), ('install_lib', 'install_dir'), ('force', 'force'), ('compile', 'compile'), ('optimize', 'optimize'), ('skip_build', 'skip_build'))
  41.         if self.compile is None:
  42.             self.compile = 1
  43.         
  44.         if self.optimize is None:
  45.             self.optimize = 0
  46.         
  47.         if type(self.optimize) is not IntType:
  48.             
  49.             try:
  50.                 self.optimize = int(self.optimize)
  51.             except (ValueError, AssertionError):
  52.                 raise DistutilsOptionError, 'optimize must be 0, 1, or 2'
  53.             except:
  54.                 None<EXCEPTION MATCH>(ValueError, AssertionError)
  55.             
  56.  
  57.         None<EXCEPTION MATCH>(ValueError, AssertionError)
  58.  
  59.     
  60.     def run(self):
  61.         self.build()
  62.         outfiles = self.install()
  63.         if outfiles is not None and self.distribution.has_pure_modules():
  64.             self.byte_compile(outfiles)
  65.         
  66.  
  67.     
  68.     def build(self):
  69.         if not self.skip_build:
  70.             if self.distribution.has_pure_modules():
  71.                 self.run_command('build_py')
  72.             
  73.             if self.distribution.has_ext_modules():
  74.                 self.run_command('build_ext')
  75.             
  76.         
  77.  
  78.     
  79.     def install(self):
  80.         if os.path.isdir(self.build_dir):
  81.             outfiles = self.copy_tree(self.build_dir, self.install_dir)
  82.         else:
  83.             self.warn("'%s' does not exist -- no Python modules to install" % self.build_dir)
  84.             return None
  85.         return outfiles
  86.  
  87.     
  88.     def byte_compile(self, files):
  89.         byte_compile = byte_compile
  90.         import distutils.util
  91.         install_root = self.get_finalized_command('install').root
  92.         if self.compile:
  93.             byte_compile(files, optimize = 0, force = self.force, prefix = install_root, dry_run = self.dry_run)
  94.         
  95.         if self.optimize > 0:
  96.             byte_compile(files, optimize = self.optimize, force = self.force, prefix = install_root, verbose = self.verbose, dry_run = self.dry_run)
  97.         
  98.  
  99.     
  100.     def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
  101.         if not has_any:
  102.             return []
  103.         
  104.         build_cmd = self.get_finalized_command(build_cmd)
  105.         build_files = build_cmd.get_outputs()
  106.         build_dir = getattr(build_cmd, cmd_option)
  107.         prefix_len = len(build_dir) + len(os.sep)
  108.         outputs = []
  109.         for file in build_files:
  110.             outputs.append(os.path.join(output_dir, file[prefix_len:]))
  111.         
  112.         return outputs
  113.  
  114.     
  115.     def _bytecode_filenames(self, py_filenames):
  116.         bytecode_files = []
  117.         for py_file in py_filenames:
  118.             ext = os.path.splitext(os.path.normcase(py_file))[1]
  119.             if ext != PYTHON_SOURCE_EXTENSION:
  120.                 continue
  121.             
  122.             if self.compile:
  123.                 bytecode_files.append(py_file + 'c')
  124.             
  125.             if self.optimize > 0:
  126.                 bytecode_files.append(py_file + 'o')
  127.                 continue
  128.         
  129.         return bytecode_files
  130.  
  131.     
  132.     def get_outputs(self):
  133.         '''Return the list of files that would be installed if this command
  134.         were actually run.  Not affected by the "dry-run" flag or whether
  135.         modules have actually been built yet.
  136.         '''
  137.         pure_outputs = self._mutate_outputs(self.distribution.has_pure_modules(), 'build_py', 'build_lib', self.install_dir)
  138.         if self.compile:
  139.             bytecode_outputs = self._bytecode_filenames(pure_outputs)
  140.         else:
  141.             bytecode_outputs = []
  142.         ext_outputs = self._mutate_outputs(self.distribution.has_ext_modules(), 'build_ext', 'build_lib', self.install_dir)
  143.         return pure_outputs + bytecode_outputs + ext_outputs
  144.  
  145.     
  146.     def get_inputs(self):
  147.         """Get the list of files that are input to this command, ie. the
  148.         files that get installed as they are named in the build tree.
  149.         The files in this list correspond one-to-one to the output
  150.         filenames returned by 'get_outputs()'.
  151.         """
  152.         inputs = []
  153.         if self.distribution.has_pure_modules():
  154.             build_py = self.get_finalized_command('build_py')
  155.             inputs.extend(build_py.get_outputs())
  156.         
  157.         if self.distribution.has_ext_modules():
  158.             build_ext = self.get_finalized_command('build_ext')
  159.             inputs.extend(build_ext.get_outputs())
  160.         
  161.         return inputs
  162.  
  163.  
  164.